import { defineStore } from "pinia";
import { ref, nextTick } from "vue";
import {
  login,
  getUserInfo,
  logout as apiLogout,
  register as apiRegister,
  updateUserInfo as apiUpdateUserInfo,
} from "@/api/user";
import { ElMessage } from "element-plus";

export const useUserStore = defineStore("user", () => {
  // 用户信息
  const userInfo = ref({
    id: "",
    username: "",
    avatar: "",
    email: "",
    role: "",
  });

  // token相关
  const token = ref("");
  const tokenExpire = ref(0);

  // 登录弹窗状态
  const isAuthModalOpen = ref(false);
  const authModalMode = ref("login"); // 'login' 或 'register'

  // 新增登录成功的事件回调列表
  const loginSuccessCallbacks = ref([]);

  // 登录成功后触发事件的方法
  const triggerLoginSuccess = async () => {
    // 延迟到下一个 tick 执行，确保其他组件已准备好接收更新
    await nextTick();

    // 执行所有注册的回调
    loginSuccessCallbacks.value.forEach((callback) => {
      try {
        callback();
      } catch (error) {
        console.error("执行登录成功回调时出错:", error);
      }
    });
  };

  // 注册登录成功回调的方法
  const onLoginSuccess = (callback) => {
    if (typeof callback === "function") {
      loginSuccessCallbacks.value.push(callback);
    }

    // 返回取消注册的函数
    return () => {
      const index = loginSuccessCallbacks.value.indexOf(callback);
      if (index !== -1) {
        loginSuccessCallbacks.value.splice(index, 1);
      }
    };
  };

  // 判断是否已登录
  // 增强 isLoggedIn 方法，加入 token 过期检查
  const isLoggedIn = () => {
    // 先检查是否有 token
    if (!token.value) return false;

    // 再检查 token 是否已过期
    if (isTokenExpired()) {
      // token 已过期，自动登出
      // 注意：这里不调用 logout 以避免无限循环，只清理数据
      clearUserData();
      return false;
    }

    // token 有效且未过期
    return true;
  };

  // 检查 token 是否已过期
  const isTokenExpired = () => {
    // 获取当前时间戳
    const currentTime = Date.now();

    // 如果没有 token 或过期时间，认为已过期
    if (!token.value || !tokenExpire.value) return true;

    // 检查是否已过期（给过期时间添加一个小的缓冲区，比如提前 30 秒过期）
    return currentTime >= tokenExpire.value - 30000;
  };

  // 清理用户数据但不发送登出请求
  const clearUserData = () => {
    // 清除用户信息
    userInfo.value = {
      id: "",
      username: "",
      avatar: "",
      email: "",
      role: "",
    };

    // 清除 token
    token.value = "";
    tokenExpire.value = 0;

    // 清除本地存储
    localStorage.removeItem("userInfo");
    localStorage.removeItem("token");
    localStorage.removeItem("tokenExpire");
  };

  // 设置用户信息
  const setUserInfo = (info) => {
    userInfo.value = { ...userInfo.value, ...info };
    // 存储到localStorage
    localStorage.setItem("userInfo", JSON.stringify(userInfo.value));
  };

  // 设置token
  const setToken = (newToken, expire = 7200000) => {
    token.value = newToken;
    tokenExpire.value = Date.now() + expire; // 默认2小时过期
    // 存储到localStorage
    localStorage.setItem("token", newToken);
    localStorage.setItem("tokenExpire", tokenExpire.value.toString());
  };

  // 初始化，从localStorage读取信息
  const initUserStore = () => {
    const storedToken = localStorage.getItem("token");
    const storedExpire = localStorage.getItem("tokenExpire");
    const storedUserInfo = localStorage.getItem("userInfo");

    if (storedToken && storedExpire && Number(storedExpire) > Date.now()) {
      token.value = storedToken;
      tokenExpire.value = Number(storedExpire);

      // 如果有token但没有用户信息，自动获取用户信息
      if (
        !storedUserInfo ||
        Object.keys(JSON.parse(storedUserInfo)).length === 0
      ) {
        fetchUserInfo();
      }
    }

    if (storedUserInfo) {
      try {
        userInfo.value = { ...userInfo.value, ...JSON.parse(storedUserInfo) };
      } catch (e) {
        console.error("Parse userInfo failed", e);
      }
    }
  };

  // 获取用户信息
  const fetchUserInfo = async () => {
    if (!token.value) return;

    try {
      const data = await getUserInfo();
      if (data) {
        setUserInfo(data);
      }
    } catch (error) {
      console.error("获取用户信息失败:", error);
      // 如果token无效，清除登录状态
      if (error.response?.status === 401) {
        logout();
      }
    }
  };

  // 退出登录
  const logout = async (callback) => {
    try {
      if (token.value) {
        // 调用退出登录API
        await apiLogout();
      }
    } catch (error) {
      console.error("退出登录API调用失败:", error);
    } finally {
      // 无论API是否成功，都清除本地状态
      userInfo.value = {
        id: "",
        username: "",
        avatar: "",
        email: "",
        role: "",
      };
      token.value = "";
      tokenExpire.value = 0;
      localStorage.removeItem("token");
      localStorage.removeItem("tokenExpire");
      localStorage.removeItem("userInfo");
      // 提示
      ElMessage.success("已退出登录");

      // 执行回调函数，可用于路由跳转
      if (typeof callback === "function") {
        callback();
      }
    }
  };

  // 打开登录弹窗
  const openAuthModal = (mode = "login") => {
    authModalMode.value = mode;
    isAuthModalOpen.value = true;
  };

  // 关闭登录弹窗
  const closeAuthModal = () => {
    isAuthModalOpen.value = false;
  };

  // 处理登录
  const handleLogin = async (credentials) => {
    try {
      // 调用登录API
      const response = await login(credentials);
      // 设置token和过期时间
      if (response.token) {
        setToken(response.token, response.expires || 7200000);
        // 获取用户信息
        if (response.userInfo) {
          setUserInfo(response.userInfo);
        } else {
          await fetchUserInfo();
        }
        // 关闭登录弹窗
        closeAuthModal();
        ElMessage.success("登录成功");

        // 触发登录成功事件
        triggerLoginSuccess();

        return { success: true };
      } else {
        return { success: false, error: "登录返回数据格式错误" };
      }
    } catch (error) {
      console.error("登录失败:", error);
      return {
        success: false,
        error: error.message || "登录失败，请检查邮箱和密码",
      };
    }
  };

  // 处理注册
  const handleRegister = async (userData) => {
    try {
      // 调用注册API
      const response = await apiRegister(userData);

      // 如果注册成功，自动登录
      if (response.token) {
        // 注册成功并返回了token，实现自动登录
        setToken(response.token, response.expires || 7200000);

        // 获取用户信息
        if (response.userInfo) {
          setUserInfo(response.userInfo);
        } else {
          await fetchUserInfo();
        }

        // 关闭登录弹窗
        closeAuthModal();
        ElMessage.success("注册成功并已自动登录");

        // 触发登录成功事件
        triggerLoginSuccess();

        return { success: true };
      } else if (response.message === "注册成功") {
        // 注册成功但没有返回token，需要进行登录
        // 切换到登录模式，保留邮箱信息便于登录
        authModalMode.value = "login";
        ElMessage.success("注册成功，请使用新注册的账号登录");

        // 返回特殊状态，让组件知道需要保留邮箱信息
        return {
          success: true,
          requireLogin: true,
          email: userData.email,
        };
      } else {
        return { success: false, error: "注册返回数据格式错误" };
      }
    } catch (error) {
      console.error("注册失败:", error);
      return {
        success: false,
        error: error.message || "注册失败，请稍后重试",
      };
    }
  };

  // 更新用户信息方法
  const updateUserInfo = async (newInfo) => {
    try {
      // 调用API更新用户信息
      const result = await apiUpdateUserInfo(newInfo);

      if (result) {
        // 更新本地存储的用户信息
        setUserInfo({
          ...userInfo.value,
          ...newInfo,
        });

        ElMessage.success("个人资料更新成功");
        return true;
      }
      return false;
    } catch (error) {
      console.error("更新用户信息失败:", error);
      ElMessage.error(error.message || "更新个人资料失败，请稍后重试");
      return false;
    }
  };

  // 初始化store
  initUserStore();

  return {
    userInfo,
    token,
    tokenExpire,
    isLoggedIn,
    setUserInfo,
    setToken,
    logout,
    fetchUserInfo,
    updateUserInfo,
    // 弹窗相关状态和方法
    isAuthModalOpen,
    authModalMode,
    openAuthModal,
    closeAuthModal,
    handleLogin,
    handleRegister,
    // 登录成功事件相关方法
    onLoginSuccess,
    triggerLoginSuccess,
    // 其他方法
    isTokenExpired,
    clearUserData,
  };
});
